import { ref, computed, watch, reactive, provide } from 'vue';
import router from "@/routers";
import { ElMessage } from 'element-plus';
import { ResultEnum } from "@/enums/httpEnum";
import { getAsideListData, getTagsListData, getTemplate } from '@/api/modules/goodsArchive/batchImport/templateDownload.ts'

















let $t = null;
/**
 * 定义一个全局状态对象
 * 该对象主要包含以下属性：
 * @param proxy 代理对象，用于中间件或数据代理场景，初始为null
 * @param taglist 标签列表数组，每个标签包含id、title、desc、checked和disabled属性
 *      - id 标签的唯一标识
 *      - title 标签的标题
 *      - desc 标签的描述信息
 *      - checked 标签是否被选中
 *      - disabled 标签是否被禁用
 * 
 * ***** 模版下载会被 商品批量导入 页面和 电子标签批量申请导入 使用
 * 
 */
const state = {
    proxy: null,
    type: ref<string>("sale"),//商品类型 大类，用来获取asideList接口数据
    business:ref<string>("goods") , //业务类型,获取规则tag接口和下载文件模版时会用到，goods-->商品、marking-->标签
    type_id: "", //商品类型id，获取规则tag接口和下载文件模版时会用到
    set: "", //set 用来区分 更细的分类
    taglist: [],//规则tag数据，初始化方法会改为ref对象
    dragList: [],//拖拽数据，初始化方法会改为ref对象 
    curTreeCheckedTypeText: ref<string>(''),
    asideOwnAllType: ref<Array<any>>([]),
    asideList: ref<Array<any>>([]),//侧边栏数据，初始化方法会改为ref对象
    asideDefaultCheckId: ref<string>(''),//
    curTypeText: ref<string>(''),
    tagsListLoading:ref<boolean>(false),
    getAsideList(params): Promise<void> {

        const formatData = (list, level) => {
            for (let index = 0; index < list.length; index++) {
                const element = list[index];
                element["id"] = element.value + "";
                if (element.childs) {
                    for (let index = 0; index < element.childs.length; index++) {
                        const son_element = element.childs[index];
                        son_element["id"] = element.value + "-" + son_element.value;
                    }
                }
            } 
            return list
        }

        const getFirst = (data) => { 
            let asideDefaultSet = data[0].childs[0].set;
            let asideDefaultCheckId = data[0].childs[0].id;
            let asideDefaultCheckLabel = data[0].childs[0].label;
            let asideDefaultCheckValue = data[0].childs[0].value;

            return {
                asideDefaultSet,
                asideDefaultCheckId,
                asideDefaultCheckLabel,
                asideDefaultCheckValue
            }
        }

        const findOption = val => {
            state.asideOwnAllType.value.find(option => {
                if (option.value == val) {
                    state.curTypeText.value = option.label;
                }
            });
        };


        /**
    * 获取侧边列表数据
    * @param params 参数对象，传递给getAsideListData函数
    */
        getAsideListData(params).then(res => {
            if (res.code == ResultEnum.SUCCESS) {
                findOption(params.type);
                state.asideList.value = formatData(res.data, 1);
                let firstData = getFirst(state.asideList.value);
                state.asideDefaultCheckId.value = firstData.asideDefaultCheckId;
                state.curTreeCheckedTypeText.value = firstData.asideDefaultCheckLabel;
                state.set = firstData.asideDefaultSet;
                state.type_id=firstData.asideDefaultCheckValue;
                state.taglist.value = [];
                state.dragList.value = [];
                state.getTagsList({ business: state.business.value, type_id: firstData.asideDefaultCheckValue, set: state.set })
            } else {
                ElMessage.error(res.message)
            }

        })



        return Promise.resolve()
    },
    getTagsList(params): Promise<void> {
        /**
    * 获取标签列表数据，并进行初始化格式化
    * @param params 参数对象，传递给getTagsListData函数
    * @returns 返回一个Promise，解决为void
    */
    
        //这个初始化默认必须使用的规则
        const initFormatData = (data): Promise<[]> => {
            let newList = []
            data.filter(item => {
                if (item.readonly) {
                    item['disabled'] = true;
                } else {
                    item['disabled'] = false;
                }
                newList.push(item)
                return false
            })
            return Promise.resolve(newList)
        }

        state.tagsListLoading.value=true
 
        //获取规则tag 数据
        getTagsListData(params).then(res => {
            state.tagsListLoading.value=false;
            if (res.code == ResultEnum.SUCCESS) {
                initFormatData(res.data).then(res => {
                    state.taglist.value = res;
                    state.draggableListInit(state.taglist.value);
                })
                
            } else {
                ElMessage.error(res.message)
            }
        })
        return Promise.resolve()
    },
    draggableListInit(data: []): Promise<void> {
        /**
    * 初始化可拖拽列表
    * @param data 初始数据数组，每个元素应包含checked属性
    * @returns 返回一个Promise，解决为void
    */
        const newList = []
        data.filter((item, index) => {
            if (item.checked) {
                newList.push(state.draggbleItem(item, index))
            }
            return false
        })

        state.dragList.value = newList;
        return Promise.resolve()
    },
    draggbleItem(item, index) {
        /**
  * 创建一个可拖拽项目的对象
  * @param item - 原始项目对象，包含名称、字段和是否禁用的信息
  * @param index - 项目的索引或唯一标识
  * @returns 返回一个包含项目名称、索引ID、字段和是否禁用的新对象
  */

        return {
            name: item.name,
            id: Math.round(Math.random() * new Date().getTime()),
            field: item.field,
            disabled: item.disabled
        }
    },
    msgs: reactive({//语言翻译
        // instructionText:"操作指南", goods_important_index
        instructionText: 'goods_important_index.manual',
        instructionTitle: 'goods_important_index.manual_dialog_title',
        selectDataComponent: 'goods_important_index.select_template_data_group',
        selectDataComponentTip: 'goods_important_index.select_template_data_group_sub',
        exportProductTemplate: 'goods_important_index.export_product_standard_template',
        exportProductTemplateTip: 'goods_important_index.export_product_standard_template_sub',
        exportTemplate: 'goods_important_index.down_import_template',
        hasKey: 'goods_important_index.down_import_has_key',
        sale: "merak.sale",
        mro: "merak.mro",
        food: "merak.food",
    }),

}



/**
 * 初始化并导出侧边栏树组件
 * 
 * 该函数没有参数。
 * @returns {Object} 返回一个包含侧边栏树组件的对象。
 */
import asideComponent from "./component/aside/index.vue";
export const UseAsideTreeInit = () => {
    const treeFilter = ref("");
    const treeRef = ref();
    // // 初始化state中的asideList为一个空的ref数组
    // state.asideList = ref([]);
    // 设置state.asideOwnAllType的值，该值为一个包含特定value和label对象的数组
    // 这些对象的value分别对应"sale", "mro", "food"，而label则对应state.msgs中相应的消息文本
    state.asideOwnAllType.value = [
        { value: "sale", label: state.msgs.sale },
        { value: "mro", label: state.msgs.mro },
        { value: "food", label: state.msgs.food }
    ]

    /**
      * 处理左侧树结构点击事件
      * @param curTree 当前被点击的树结构节点对象
      * 该函数不返回任何内容
      */
    const changeTree = (curTree) => {
        // 如果当前节点没有子节点，则更新type_id并获取标签列表
        if (!curTree.childs) {
            state.type_id = curTree.value; // 设置type_id为当前节点的值
            state.set = curTree.set; // 设置set为当前节点下的详细分类
            state.curTreeCheckedTypeText.value = curTree.label; // curTreeCheckedTypeText
            state.getTagsList({ business: state.business.value, type_id: curTree.value, set: state.set }); // 根据新的type_id获取标签列表

        }



    }


    /**
    * 初始化树组件
    * @param type 树状结构的类型，用于定义初始化的类型
    * 该函数没有返回值
    */
    const initTree = (type) => {
        // 设置状态类型的值为传入的type
        state.type.value = type;
        // 根据新设置的类型值获取侧边栏列表
        state.getAsideList({ type: state.type.value });
    }







    return {
        asideTreeComponent: asideComponent,
        asideList: state.asideList,
        changeTree,
        initTree,
        type: state.type,
        asideOwnAllType: state.asideOwnAllType,
        curTreeCheckedTypeText: state.curTreeCheckedTypeText,
        asideDefaultCheckId: state.asideDefaultCheckId,
        curTypeText: state.curTypeText,
        treeFilter,
        treeRef,

    }
}



/**
 * 初始化并管理标签列表的函数。
 * 无参数。
 * @returns 返回一个对象，包含标签组件、标签列表和列表变化时的处理函数。
 */
import tagComponent from "./component/dataTag/index.vue";
export const UseTagListInit = () => {
    // 初始化tag列表为空数组
    state.taglist = ref([]);

    // 当tagList发生变化时处理数据的函数
    const tagChange = (curData) => {
        curData = JSON.parse(curData);
        // 如果当前数据被选中，则添加到dragList中
        if (curData.checked) {
            state.dragList.value.push(state.draggbleItem(curData, state.dragList.value.length))
        }
        // 如果当前数据未被选中，则从dragList中移除
        if (!curData.checked) {
            state.dragList.value.filter((item, index) => {
                if (item.field === curData.field) {
                    state.dragList.value.splice(index, 1)
                }
                return false
            })
        }
    }
    // 返回相关组件和数据
    return {
        dataTagsComponent: tagComponent,
        tagList: state.taglist,
        tagChange
    }
}



/**
 * 初始化并导出指令组件
 * 该函数没有参数。
 * @returns {Object} 返回一个对象，包含一个名为instructionComponent的属性，其值为instruction组件。
 */
import instruction from "./component/instruction/index.vue";
export const UseInstructionInit = () => {
    return {
        instructionComponent: instruction,
        msgs: state.msgs,
     
    }
}
/**
 * 初始化并提供可拖拽组件及其相关功能
 * 该函数没有参数。
 * @returns {Object} 返回一个对象，包含以下属性：
 * - draggableComponent: 引入的可拖拽组件
 * - dragList: 一个ref对象，用于存储拖拽列表的当前状态
 * - dragChange: 一个函数，用于更新拖拽列表的状态
 */
import draggableComponent from "./component/draggable/index.vue";
export const UseDraggableInit = () => {
    state.dragList = ref([])// 初始化拖拽列表为空数组
    const dragChange = (list) => {
        // 更新拖拽列表的状态为传入列表的深拷贝
        state.dragList.value = JSON.parse(JSON.stringify(list))
    }
    return {
        draggableComponent,
        dragList: state.dragList,
        dragChange
    }
}



/**
 * 初始化下载模板的功能
 * @param proxy 代理对象，用于访问特定的方法和属性
 * @returns 返回包含下载模板方法的对象
 */
export const templateDownInit = (proxy) => {
    state.proxy = proxy;
    $t = proxy.$t;
    state.business.value="goods" //还原默认值

    // 初始化翻译
    const initMsgs = () => {
        Object.keys(state.msgs).filter(item => {
            state.msgs[item] = $t(state.msgs[item])
            return false
        })
    }
    initMsgs();

    //初始化获取路由参数,获取左侧树类型
    const getRouterParams = (router) => {
        return Promise.resolve(Object.assign({}, router.currentRoute.value.query))
    }
    getRouterParams(router).then(res => {
        console.log(res);
        if (res?.type) {
            state.type.value = res.type;
        }
        if(res?.bussiness_type){// 用户电子标签导入页面功能
            state.business.value = res.bussiness_type;
        }
        //获取左侧菜单数据 
        state.getAsideList({ type: state.type.value });
    })



    //获取模版
    const downTemplate = () => {
        let fields = [];
        state.dragList.value.filter(item => {
            fields.push(item.field)
            return false
        })
        console.log(state.set)
        getTemplate({
            business: state.business.value,
            type_id: state.type_id,
            type: state.type.value,
            set: state.set + '',
            fields
        }).then(res => {
            if (res.code == ResultEnum.SUCCESS) {
                downLoadFile(res.data.file)
            } else {
                ElMessage.error(res.data)
            }

        })

    }
    //下载模板
    const downLoadFile = (path) => {
        const fileUrl = path; // 文件的URL地址
        const link = document.createElement('a');
        const fileName = path.split("/").slice(-1);
        link.href = fileUrl;
        link.setAttribute('download', fileName);
        link.click();
    }

    return {
        downTemplate,
        loading:state.tagsListLoading
    }
}













